package com.ng.common.component.engine.parser;

/**
 * 逻辑运算工具类
 * 提供基本和复合的位运算操作
 */
public final class LogicOperations {
    
    // 私有构造函数防止实例化
    private LogicOperations() {
        throw new AssertionError("Utility class should not be instantiated");
    }

    /**
     * 按位与（AND）运算
     * 示例: 5(0101) AND 3(0011) = 1(0001)
     *
     * @param a 第一个操作数
     * @param b 第二个操作数
     * @return 两个操作数的按位与结果
     */
    public static int and(int a, int b) {
        return a & b;
    }

    /**
     * 按位或（OR）运算
     * 示例: 5(0101) OR 3(0011) = 7(0111)
     *
     * @param a 第一个操作数
     * @param b 第二个操作数
     * @return 两个操作数的按位或结果
     */
    public static int or(int a, int b) {
        return a | b;
    }

    /**
     * 按位非（NOT）运算
     * 示例: NOT 5(0101) = -6(1010)
     *
     * @param a 操作数
     * @return 操作数的按位非结果
     */
    public static int not(int a) {
        return ~a;
    }

    /**
     * 按位异或（XOR）运算
     * 示例: 5(0101) XOR 3(0011) = 6(0110)
     *
     * @param a 第一个操作数
     * @param b 第二个操作数
     * @return 两个操作数的异或结果
     */
    public static int xor(int a, int b) {
        return a ^ b;
    }

    /**
     * 非与（NAND）运算
     * NAND = NOT(AND)
     *
     * @param a 第一个操作数
     * @param b 第二个操作数
     * @return 两个操作数的NAND结果
     */
    public static int nand(int a, int b) {
        return not(and(a, b));
    }

    /**
     * 非或（NOR）运算
     * NOR = NOT(OR)
     *
     * @param a 第一个操作数
     * @param b 第二个操作数
     * @return 两个操作数的NOR结果
     */
    public static int nor(int a, int b) {
        return not(or(a, b));
    }

    /**
     * 同或（XNOR）运算
     * XNOR = NOT(XOR)
     *
     * @param a 第一个操作数
     * @param b 第二个操作数
     * @return 两个操作数的XNOR结果
     */
    public static int xnor(int a, int b) {
        return not(xor(a, b));
    }

    /**
     * 检查一个数的指定位是否为1
     *
     * @param num 要检查的数
     * @param position 要检查的位置（0-31）
     * @return 如果指定位为1返回true，否则返回false
     * @throws IllegalArgumentException 如果位置超出范围
     */
    public static boolean isBitSet(int num, int position) {
        if (position < 0 || position > 31) {
            throw new IllegalArgumentException("Position must be between 0 and 31");
        }
        return (num & (1 << position)) != 0;
    }

    /**
     * 设置一个数的指定位为1
     *
     * @param num 要修改的数
     * @param position 要设置的位置（0-31）
     * @return 设置后的结果
     * @throws IllegalArgumentException 如果位置超出范围
     */
    public static int setBit(int num, int position) {
        if (position < 0 || position > 31) {
            throw new IllegalArgumentException("Position must be between 0 and 31");
        }
        return num | (1 << position);
    }

    /**
     * 清除一个数的指定位（设置为0）
     *
     * @param num 要修改的数
     * @param position 要清除的位置（0-31）
     * @return 清除后的结果
     * @throws IllegalArgumentException 如果位置超出范围
     */
    public static int clearBit(int num, int position) {
        if (position < 0 || position > 31) {
            throw new IllegalArgumentException("Position must be between 0 and 31");
        }
        return num & ~(1 << position);
    }

    /**
     * 切换一个数的指定位（0变1，1变0）
     *
     * @param num 要修改的数
     * @param position 要切换的位置（0-31）
     * @return 切换后的结果
     * @throws IllegalArgumentException 如果位置超出范围
     */
    public static int toggleBit(int num, int position) {
        if (position < 0 || position > 31) {
            throw new IllegalArgumentException("Position must be between 0 and 31");
        }
        return num ^ (1 << position);
    }

    /**
     * 获取一个数中1的个数
     *
     * @param num 要计算的数
     * @return 1的个数
     */
    public static int countOneBits(int num) {
        return Integer.bitCount(num);
    }

    /**
     * 将数字转换为二进制字符串
     *
     * @param num 要转换的数
     * @return 32位二进制字符串
     */
    public static String toBinaryString(int num) {
        return String.format("%32s", Integer.toBinaryString(num)).replace(' ', '0');
    }

    /**
     * 测试类，用于验证所有逻辑运算的结果
     */
    public static void main(String[] args) {
        // 测试 AND、OR、NOT、XOR
        System.out.println("=== 基本逻辑运算 ===");
        testBasicLogic();

        // 测试 NAND、NOR、XNOR
        System.out.println("\n=== 复合逻辑运算 ===");
        testCompositeLogic();
    }

    /**
     * 测试基本逻辑运算
     */
    private static void testBasicLogic() {
        int a = 5;   // 二进制：0101
        int b = 3;   // 二进制：0011

        System.out.println("输入 a = " + a);
        System.out.println("输入 b = " + b);

        System.out.println("AND(a, b) = " + LogicOperations.and(a, b));
        System.out.println("OR(a, b) = " + LogicOperations.or(a, b));
        System.out.println("NOT(a) = " + LogicOperations.not(a));
        System.out.println("XOR(a, b) = " + LogicOperations.xor(a, b));
    }

    /**
     * 测试复合逻辑运算
     */
    private static void testCompositeLogic() {
        int a = 5;   // 二进制：0101
        int b = 3;   // 二进制：0011

        System.out.println("输入 a = " + a);
        System.out.println("输入 b = " + b);

        System.out.println("NAND(a, b) = " + LogicOperations.nand(a, b));
        System.out.println("NOR(a, b) = " + LogicOperations.nor(a, b));
        System.out.println("XNOR(a, b) = " + LogicOperations.xnor(a, b));
    }
}